package com.cx.purchase.spare.service.impl;


import com.cx.purchase.config.DateTimeString;
import com.cx.purchase.plan.model.PlanClassAddVo;
import com.cx.purchase.util.CurrencyCode;
import com.cx.purchase.util.Status;
import com.cx.purchase.config.ResultVO;
import com.cx.purchase.config.ResultVOBuilder;
import com.cx.purchase.spare.mapper.SpareMapper;
import com.cx.purchase.spare.model.*;
import com.cx.purchase.spare.service.SpareSerivce;
import com.cx.purchase.util.AllrecordsVo;
import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFDateUtil;
import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.joda.time.DateTime;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import java.util.*;

@Service
public class SpareServiceImpl implements SpareSerivce {
    @Autowired
    private SpareMapper spareMapper;
    @Override
    public ResultVO queryPage(SpareSelectVo spareSelectVo) {
        List<SpareVo>  spareVoList = spareMapper.queryData(spareSelectVo);
        for (SpareVo sl:
             spareVoList) {
            if(sl.getStatus()){
                sl.setStatusName("启用");
            }else{
                sl.setStatusName("禁用");
            }
           /* if(sl.getCurrencyCode()=="2"){
                sl.setCurrencyCodeName("人民币");
            }else {
                sl.setCurrencyCodeName("美元");
            }*/

        }



        int count = spareMapper.queryCount(spareSelectVo);

        AllrecordsVo allrecordsVo = new AllrecordsVo();
        allrecordsVo.setTotalPage(spareSelectVo.getPageIndex());
        allrecordsVo.setPageSize(spareSelectVo.getPageSize());
        allrecordsVo.setTotalSize(count);
        allrecordsVo.setDataList(spareVoList);
        allrecordsVo.resettotalNum(count);

        return ResultVOBuilder.success(allrecordsVo);

    }

    @Override
    public ResultVO queryAllTaxType( ) {
        List<TaxTypeSelectVo> taxTypeSelectVos = spareMapper.querytaxtypeId();
        return ResultVOBuilder.success(taxTypeSelectVos);
    }

    @Override
    public ResultVO queryPlantListByLegalPersonCode(SelectByLegalPersonCode selectByLegalPersonCode) {

       List<String> list = spareMapper.queryPlantCode(selectByLegalPersonCode);

        return ResultVOBuilder.success(list);
    }

    @Override
    public ResultVO queryPullList() {
        HashMap<String, List<status>> map = new HashMap<>();

        /*ArrayList<status> list1 = new ArrayList<>();
        status status = new status();
        status.setValue(0);
        status.setLabel("美元");
        status status1 = new status();
        status1.setValue(1);
        status1.setLabel("人民币");
        list1.add(status);
        list1.add(status1);*/
        ArrayList<status> list1 = new ArrayList<>();
        for (CurrencyCode code: CurrencyCode.values()) {
            status status = new status();
            status.setValue(code.getStatus());
            status.setLabel(code.getStatusName());
            list1.add(status);

        }


        map.put("currencyCode",list1);


        /*ArrayList<status> list2 = new ArrayList<>();
        status status3 = new status();
        status3.setValue(Status.JINYONG.getStatus());
        status3.setLabel(Status.JINYONG.getStatusName());
        status status4 = new status();
        status4.setValue(Status.QIYONG.getStatus());
        status4.setLabel(Status.QIYONG.getStatusName());
        list2.add(status3);
        list2.add(status4);*/

        ArrayList<status> list2 = new ArrayList<>();
        for (Status statu : Status.values()) {
            status status3 = new status();
            status3.setLabel(statu.getStatusName());
            status3.setValue(statu.getStatus());
            list2.add(status3);
        }

        
        
        map.put("materialCostPrice.materialCostPriceStatus",list2);

        ArrayList<status> list3 = spareMapper.queryCurrencyCode();
        map.put("materialCostPrice.priceType",list3);



        return ResultVOBuilder.success(map);
    }

    @Override
    public ResultVO searchEnabled(SpareLiSelectVo spareLiSelectVo) {
        List<SpareLiSelectVo> melist =  spareMapper.queryMeData(spareLiSelectVo);
        int count = spareMapper.queryMeCount(spareLiSelectVo);

        AllrecordsVo allrecordsVo = new AllrecordsVo();
        allrecordsVo.setPageIndex(spareLiSelectVo.getPageIndex());
        allrecordsVo.setPageSize(spareLiSelectVo.getPageSize());
        allrecordsVo.setTotalNumber(count);
        allrecordsVo.setDataList(melist);
        allrecordsVo.resettotalNum(count);

        return ResultVOBuilder.success(allrecordsVo);
    }

    @Override
    public ResultVO add(SpareAdd spareAdd) {



        SpareVo spareVo = spareMapper.querySpare(spareAdd);
        if(spareVo!=null){
            //同一个价格,直接增加
            if(spareVo.getPrice() == spareAdd.getPrice()) {
                spareMapper.add(spareVo);
            }else{
                //新的开始大于等于旧的开始
                if (spareAdd.getStartTime().getTime() >= spareVo.getStartTime().getTime()){
                    //新的结束时间小于旧的结束时间
                    if(spareAdd.getEndTime().getTime() < spareVo.getEndTime().getTime()){

                        long time1 = spareVo.getStartTime().getTime();
                        long endTime = spareAdd.getEndTime().getTime();
                        long time = 24*60*60*1000;//一天的毫秒
                        Date date = new Date(time1 + endTime);
                        spareMapper.update1(date,spareVo.getId());


                        //旧.开始 改为 新.结束+1
                    //  新的结束时间大于旧的结束时间
                    }else{
                        //先删旧的后插新的
/*
                        delete from biao where id = id;//删除旧的
                    
*/                      spareMapper.delete1(spareVo.getId());
                        //调用add                       update2()
                        SpareVo spareVo1 = new SpareVo();
                        BeanUtils.copyProperties(spareAdd,spareVo1);

                        spareMapper.add(spareVo1);


                    }
                    //新的开始小于等于旧的开始时间
                }else{

                    //新的结束时间小于旧的结束时间
                        if(spareAdd.getEndTime().getTime()<spareVo.getEndTime().getTime()){



                            long time1 = spareAdd.getEndTime().getTime()+24*60*60*1000;
                            Date date = new Date(time1);

                            spareMapper.update2(date,spareVo.getId());

                                
                            //新的结束时间大于的结束时间
                        }else{
                            //新的所以时间段包括了旧的时间段
                            //前提 先删除旧的数据  在插入新的数据


                            spareMapper.delete1(spareVo.getId());
                            SpareVo spareVo1 = new SpareVo();
                            BeanUtils.copyProperties(spareAdd,spareVo1);

                            spareMapper.add(spareVo1);


                        }


                }
            }
        }


        String name = "张三";
        Date date = new Date();
        SpareVo spareVo2 = new SpareVo();
        BeanUtils.copyProperties(spareAdd,spareVo2);
        spareVo2.setCreateName(name);
        spareVo2.setCreateTime(date);
        spareVo2.setUpdateName(name);
        spareVo2.setUpdateTime(date);

        spareMapper.add(spareVo2);
        return ResultVOBuilder.success(spareVo2);
    }

    @Override
    public ResultVO updateStatus(SpareUpdateStatus spareUpdateStatus) {
        String name = "张三";
        Date date = new Date();
        SpareVo spareVo = new SpareVo();

        //由于目前对象没有添加的功能所以将添加的功能付给 目前的这个对象
        BeanUtils.copyProperties(spareUpdateStatus,spareVo);

        spareVo.setUpdateName(name);
        spareVo.setUpdateTime(date);

        System.out.println(spareVo);

        spareMapper.updateStatus(spareVo);

        return ResultVOBuilder.success();
    }

    @Override
    public ResultVO update(SpareUpdate spareUpdate) {
        String name = "张三";
        Date date = new Date();
        SpareVo spareVo = new SpareVo();
        BeanUtils.copyProperties(spareUpdate,spareVo);
        spareVo.setCreateName(name);
        spareVo.setCreateTime(date);
        spareVo.setUpdateName(name);
        spareVo.setUpdateTime(date);

        spareMapper.update(spareVo);
        return ResultVOBuilder.success(spareVo);


    }

    /**
     *   2.提示版本问题，询问产品经理支持哪种版本的导入格式，2007版本的导入模板，根据版本不同，poi导入技术的读取方式不同
     3.模板是否是需要导入的模板，验证模板是否正确
     4.格式问题，必须保持统一格式，统一为字符串格式导入
     5.验证不为空字段是否为空
     6.验证字符长度是否符合需求
     7.验证数据是否存在也就是是否合法
     8.验证数据是否重复
     9.对于需要转换的数据进行数据转换，比如数据库存的数据为数字格式，用户输入的为汉字，需要把汉字转换为数字存储

     * @param file
     * @return
     */
    @Override
    public ResultVO importFile(MultipartFile file ,SpareAdd spareAdd) throws Exception {
        //怎样验证模板是否正确呢？
        //引入poi读取表格数据，验证内容是否是计划大类的内容。
        //引入poi步骤  1.导包  2.引入xssf工具类完成读取
        ResultVO resultVo = poiImport(file);
        if (!resultVo.isSuccess()){
            return resultVo;
        }

        //数据放入集合中
        List<SpareAdd> All = (List<SpareAdd>) resultVo.getData();
        System.out.println(All);


        //有了数据就要验证数据了
        // 5.验证不为空字段是否为空

//        6.验证字符长度是否符合需求
//        7.验证数据是否存在也就是是否合法
//        8.验证数据是否重复
        ResultVO  reAll =  quchong(All);
        if(!reAll.isSuccess()){
            return reAll;
        }


//        9.对于需要转换的数据进行数据转换，比如数据库存的数据为数字格式，用户输入的为汉字，需要把汉字转换为数字存储
        List<SpareAdd> sussceList  = (List<SpareAdd>) reAll.getData();

        for (SpareAdd s : sussceList) {
            if(s.getStatusName().equals("启用")){
                s.setStatus(true);
            }else {
                s.setStatus(false);
            }
            s.setLegalPersonCode(spareAdd.getLegalPersonCode());
            s.setLegalPersonName(spareAdd.getLegalPersonName());
            s.setPriceType(spareAdd.getPriceType());
            s.setPriceTypeName(spareAdd.getPriceTypeName());


            //将String时间转为date然后存入对象当中
            Date startDate = DateTimeString.toDateTime(s.getStarTimeName());
            Date endDate = DateTimeString.toDateTime(s.getEndTimeName());

            s.setStartTime(startDate);
            s.setEndTime(endDate);

            //将String类型转成Double
            double price = Double.parseDouble(s.getPriceName());
            s.setPrice(price);

        }
        //打印所有的数据进行查看
        System.out.println("看看状态以及时间是否改变了"+sussceList);


        String name = "张三";
        Date date = new Date();
        for (SpareAdd list:sussceList) {
            list.setUpdateName(name);
            list.setUpdateTime(date);
            list.setCreateName(name);
            list.setCreateTime(date);
        }
        System.out.println("SpareAdd"+sussceList);

        //批量添加到数据库




//        int i = 0;
//        for (SpareAdd list:sussceList) {
//            if(i>200){
//                return  ResultVOBuilder.success("最大只支持导入200条数据,前200条数据已经入库");
//            }
//            spareMapper.addAll(list);
//            i++;
//        }



        return  ResultVOBuilder.success();
    }


//    private ResultVo validateImport(){
//
//    }

    //poi读取信息
    public ResultVO poiImport(MultipartFile file)throws Exception{
        //        3.模板是否是需要导入的模板，验证模板是否正确
        XSSFWorkbook workbook = new XSSFWorkbook(file.getInputStream());
        //获取单元格中的信息 at0是获取sheet1中的数据。
        XSSFSheet sheet = workbook.getSheetAt(0);
        System.out.println(sheet.getRow(sheet.getFirstRowNum()).getCell(0));
        //验证第一列第一行的表格标头信息是否为 “询价单导入”，如果不是，提示模板错误。
        if (!String.valueOf(sheet.getRow(sheet.getFirstRowNum()).getCell(0)).equals("备件成本价导入")) {
            return ResultVOBuilder.error("模板错误，请检查模板！");
        }
        //定义一个集合用来存放表格中的数据
        List<SpareAdd> spareAdds = new ArrayList<>();
        //遍历excel表格中的所有数据，从第五行开始读取，没有数据时终止遍历。
        for (int i = sheet.getFirstRowNum() + 4; i <= sheet.getLastRowNum(); i++) {
            //读取每一行的数据
            XSSFRow xssfRow = sheet.getRow(i);
            if(xssfRow != null){
                //读取列的条数
                int cellCount = xssfRow.getPhysicalNumberOfCells();

                for(int cellNum = 0; cellNum < cellCount; cellNum++ ){
                    XSSFCell cell = xssfRow.getCell(cellNum);
                    //匹配数据类型
                    if(cell!=null){
                        int cellType = cell.getCellType();
                        switch (cellType){
                            case HSSFCell.CELL_TYPE_STRING://字符串
                                String stringCellValue = cell.getStringCellValue();
                                break;
                            case HSSFCell.CELL_TYPE_NUMERIC://数字 (日期,普通数字)
                                if(HSSFDateUtil.isCellDateFormatted(cell)){//日期
                                    Date date = cell.getDateCellValue();
                                    String cellValue = new DateTime(date).toString("yyyy-MM-dd");
//                                    String cellValue = date.toString();
                                }else {
                                    cell.setCellType(HSSFCell.CELL_TYPE_STRING);
                                    String cellValue = cell.toString();
                                }
                                break;
                        }

                    }

                }


                String test1 = String.valueOf(xssfRow.getCell(1)).trim();
                String test2 = String.valueOf(xssfRow.getCell(2)).trim();
                String test3 = String.valueOf(xssfRow.getCell(3)).trim();
                String test4 = String.valueOf(xssfRow.getCell(4)).trim();
                String test5 = String.valueOf(xssfRow.getCell(7)).trim();
                String test6 = String.valueOf(xssfRow.getCell(8)).trim();

                if (!test1.equals("")&&!test1.equals("null")
                        ||!test2.equals("")&&!test2.equals("null")
                        ||!test3.equals("")&&!test3.equals("null")
                        ||!test4.equals("")&&!test4.equals("null")
                        ||!test5.equals("")&&!test5.equals("null")
                        ||!test6.equals("")&&!test6.equals("null")
                    ){


                    //把每一行的数据放入到实体类中
                    ResultVO<SpareAdd> inquiryImportVo = build(xssfRow);
                    if (!inquiryImportVo.isSuccess()){
                        return inquiryImportVo;
                    }
                    //把实体类中的数据放入到list集合中
                    spareAdds.add(inquiryImportVo.getData());
                }

            }
        }
        return ResultVOBuilder.success(spareAdds);
    }

    public ResultVO build(XSSFRow xssfRow){
        SpareAdd spareAdd = new SpareAdd();
        //        4.格式问题，必须保持统一格式，统一为字符串格式导入
        spareAdd.setMaterialCode(String.valueOf(xssfRow.getCell(1)));
        spareAdd.setMaterialName(String.valueOf(xssfRow.getCell(2)));
        spareAdd.setStatusName(String.valueOf(xssfRow.getCell(3)));
        spareAdd.setCurrencyCode(String.valueOf(xssfRow.getCell(4)));
        spareAdd.setTaxType(String.valueOf(xssfRow.getCell(5)));
        spareAdd.setPriceName(String.valueOf(xssfRow.getCell(6)));
        spareAdd.setStarTimeName(String.valueOf(xssfRow.getCell(7)));
        spareAdd.setEndTimeName(String.valueOf(xssfRow.getCell(8)));
        spareAdd.setRemark(String.valueOf(xssfRow.getCell(9)));
        return ResultVOBuilder.success(spareAdd);
    }



    /**
     *查看是否重复或者  为空
     */
    public ResultVO quchong( List<SpareAdd>  All){
        //检查文档是否有重复
        List<String> codeList = new ArrayList<>();
        List<String> nameList = new ArrayList<>();


        for (SpareAdd a:All) {
            codeList.add(a.getMaterialCode());
            nameList.add(a.getMaterialName());
        }
        //去重code
        HashSet<String> codeSet = new HashSet<>(codeList);
        //去重name
        HashSet<String> nameSet = new HashSet<>(nameList);

        //去重后放入集合中
        if(codeList.size()!= codeSet.size()){
            ResultVOBuilder.error("有重复的编码,请检查你的文档");
        }
        if(nameList.size()!=nameSet.size()){
            ResultVOBuilder.error("有重复的名称,请检查你的文档");
        }

        //检查文档与数据库中是否有重复的名称及编码
        //查询数据库里的所有编码以及名称
        List<String> AllCode = spareMapper.queryCode();
        List<String> AllName = spareMapper.queryName();

        //将excl表中的编码,名称;加到查出来的编码,名称集合
        for ( String  list:codeList ) {
            AllCode.add(list);
        }
        for ( String  list:nameList ) {
            AllName.add(list);
        }
        //对所有的code去重后比较大小
        HashSet<String> quchongCode = new HashSet<>(AllCode);

        if(quchongCode.size() != AllCode.size()){

            //存放的重复的集合
            List<String> repeatCodeList = new ArrayList<>();
            //存放的不重复的集合
            List<String> codeList2 = new ArrayList<>();

            for (String  a :AllName){
                if (a.contains(a)){
                    //包含证明重复了
                    repeatCodeList.add(a);
                }else {
                    //不包含证明不重复
                    codeList2.add(a);
                }
            }

            return ResultVOBuilder.error("库中已存在相应的编码,文档中重复的编码是"+repeatCodeList);
        }

        //对所有的name去重后比较大小
        HashSet<String> quchongName = new HashSet<>(AllName);

        if(quchongName.size() != AllName.size()){
            //删除
            //存放的重复的集合
            List<String> repeatNameList = new ArrayList<>();
            //存放的不重复的集合
            List<String> nameList2 = new ArrayList<>();

            for (String  a :AllCode){
                if (a.contains(a)){
                    //包含证明重复了
                    repeatNameList.add(a);
                }else {
                    //不包含证明不重复
                    nameList2.add(a);
                }
            }

            if (repeatNameList.size()>0){
                return ResultVOBuilder.error("库中已存在相应的名称,文档中重复的是"+repeatNameList);
            }

        }
        return ResultVOBuilder.success(All);
    }
}
